﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace RobotCleaner
{
    /// <summary>
    /// 清扫算法类
    /// </summary>
    public class CleanAlgorithm
    {
        /// <summary>
        /// 清扫分析类实例化
        /// </summary>
        CleanAnalyze analyzer = new CleanAnalyze();
        ///// <summary>
        ///// Debug类
        ///// </summary>
        //CleanDebug cleanDebug = new CleanDebug();
        #region 清扫算法
        /// <summary>
        /// 机器人 清扫地面 左拐
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanTurnLeft(Map map, Robot r, Panel panel)
        {
            // 机器人 左拐行走
            robotGoByTurnLeft(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人 清扫地面 随机
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void robotGoByStochastic(Map map, Robot r, Panel panel)
        {
            // 检测随机碰撞和污浊区域
            checkCollideAndDirtyForStochastic(map, r, panel);
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 机器人 清扫地面 右拐
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanTurnRight(Map map, Robot r, Panel panel)
        {
            // 机器人 右拐行走
            robotGoByTurnRight(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人按照左拐 N度行走
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="c"></param>
        /// <param name="panel"></param>
        private void robotGoByTurnLeft(Map map, Robot r, Panel panel)
        {
            // 检测碰撞
            checkCollideForTurnLeft(map, r, panel);
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 机器人按照右拐 N度行走
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="c"></param>
        /// <param name="panel"></param>
        private void robotGoByTurnRight(Map map, Robot r, Panel panel)
        {
            // 检测右转的碰撞
            checkCollideForTurnRight(map, r, panel);
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 机器人 清扫地面 沿墙
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanWall(Map map, Robot r, Panel panel)
        {
            // 检测沿墙模式 碰撞
            checkCollideForCleanWall(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人 清扫地面 螺旋
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanSpiral(Map map, Robot r, Panel panel)
        {
            // 检测螺旋碰撞
            checkCollideForCleanSpiral(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人 清扫地面 后退
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanBackwards(Map map, Robot r, Panel panel)
        {
            // 检测后退碰撞
            checkCollideForCleanBackwards(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人 清扫地面 左右交替
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanLeftRight(Map map, Robot r, Panel panel)
        {
            // 检测左右交替碰撞
            checkCollideForCleanLeftRight(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 检测沿障碍物转弯
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkTurningForCleanRound(Map map, Robot r, Panel panel)
        {
            //for (int i = 0; i < r.t.Length; i++)
            //{
            for (int j = 0; j < map.ObstaclePoint.Count; j++)
            {
                if (r.Angle == 0 &&
                    r.get_Center_X_Y().X -
                    r.get_step() <= map.ObstaclePoint[j].O_X
                    + map.ObstaclePoint[j].O_width)
                {
                    r.setAngle(-90);
                }
                // 沿障碍物顶点往下转
                if (r.Angle == 0 &&
                    map.ObstaclePoint[j].O_X
                    - r.get_Center_X_Y().X >= r.R_Width / 2)
                {
                    r.setAngle(90);
                    break;
                }
                // 沿障碍物左下点往右转
                if (r.Angle == 90 &&
                    r.get_Center_X_Y().Y
                    - (map.ObstaclePoint[j].O_Y
                    + map.ObstaclePoint[j].O_height) >= r.R_Height / 2)
                {
                    r.setAngle(90);
                    break;
                }
                // 沿障碍物右下点往上转
                if (r.Angle == 180 &&
                    r.get_Center_X_Y().X
                    - (map.ObstaclePoint[j].O_X
                    + map.ObstaclePoint[j].O_width) >= r.R_Width / 2)
                {
                    r.setAngle(90);
                    break;
                }
                // 沿障碍物右上往左转
                if (r.Angle == 270 &&
                    map.ObstaclePoint[j].O_Y
                    - r.get_Center_X_Y().Y >= r.R_Height / 2)
                {
                    r.setAngle(90);
                    r.R_RUN_MODE = -1;
                    MessageBox.Show("r.R_RUN_MODE = -1;");
                    break;
                }
            }
            //}
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 检测沿墙模式 碰撞
        /// </summary>
        /// <param name="map">地图</param>
        /// <param name="r">机器人</param>
        /// <param name="panel">行走区域</param>
        private void checkCollideForCleanWall(Map map, Robot r, Panel panel)
        {
            // 沿墙未完成
            if (!r.CleanWallFinished)
            {
                // 障碍物的碰撞
                checkObstacleCollideForWall(map, r, panel);
                // 墙壁的碰撞
                checkWallCollideForWall(map, r, panel);
            }
            else
            {
                // 恢复默认未完成沿墙
                r.CleanWallFinished = false;
                // 改变模式为 默认（随机）
                r.R_RUN_MODE = 3;
            }
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 检测螺旋碰撞
        /// </summary>
        /// <param name="map">地图</param>
        /// <param name="r">机器人</param>
        /// <param name="panel">行走区域</param>
        private void checkCollideForCleanSpiral(Map map, Robot r, Panel panel)
        {
            // 检测 是否已经离开 污浊区域
            for (int k = 0; k < map.DirtyPoint.Count; k++)
            {
                if (IsBiggerThanDiameter(r, map.DirtyPoint[k]))
                {
                    // 还原绕圈数据
                    r.RountCount = 0;
                    r.AnglesRound = 0;
                    // 改变运行模式
                    r.R_RUN_MODE = -1;
                }
            }
            // 障碍物的碰撞
            for (int i = 0; i < map.ObstaclePoint.Count; i++)
            {
                for (int j = 0; j < r.t.Length; j++)
                {
                    if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                        r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                                   + map.ObstaclePoint[i].O_height &&
                        r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                        r.t[j].T_X < map.ObstaclePoint[i].O_X
                                   + map.ObstaclePoint[i].O_width)
                    {
                        r.setAngle(r.angles[this.generateRandom()]);
                        break;
                    }
                }
            }
            // 墙壁碰撞检测
            for (int i = 0; i < r.t.Length; i++)
            {
                if (r.t[i].T_X + r.get_step() >= 0 &&
                    r.t[i].T_Y + r.get_step() >= 0 &&
                    r.t[i].T_X - r.get_step() <= panel.Width &&
                    r.t[i].T_Y - r.get_step() <= panel.Height)
                {
                    r.AnglesRound += 15.0f;
                    if (r.AnglesRound > 360)
                    {
                        r.RountCount++;
                        r.AnglesRound = 0;
                    }
                    r.setAngle(15.0f - r.RountCount);
                    break;
                }
                else
                {
                    r.R_RUN_MODE = -1;
                }
            }
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 检测后退碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkCollideForCleanBackwards(Map map, Robot r, Panel panel)
        {
            // 障碍物的碰撞
            checkObstacleCollideForCleanBackwards(map, r, panel);
            // 墙壁的碰撞
            checkWallCollideForCleanBackwards(map, r, panel);
            // 判断是否碰撞
            if (r.R_RUN_MODE != -1)
            {
                if (r.bBackwardAhead)
                {
                    r.StepForBackwards++;
                    if (r.StepForBackwards >= r.MaxStepForBackwards)
                    {
                        r.StepForBackwards = 0;
                        r.setAngle(180);
                        r.bBackwardAhead = false;
                    }
                }
                else
                {
                    r.StepForBackwards++;
                    if (r.StepForBackwards >= r.MaxStepForBackwards)
                    {
                        r.StepForBackwards = 0;
                        r.setAngle(195);
                        r.bBackwardAhead = true;
                    }
                }
            }
            else
            {
                r.StepForBackwards = 0;
            }
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 检测左右交替碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkCollideForCleanLeftRight(Map map, Robot r, Panel panel)
        {
            // 障碍物的碰撞
            // Code here
            // 墙壁的碰撞
            // Code here
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 检测左转的碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        /// <returns></returns>
        private void checkCollideForTurnLeft(Map map, Robot r, Panel panel)
        {
            // 障碍物的碰撞
            for (int i = 0; i < map.ObstaclePoint.Count; i++)
            {
                for (int j = 0; j < r.t.Length; j++)
                {
                    if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                        r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                                   + map.ObstaclePoint[i].O_height &&
                        r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                        r.t[j].T_X < map.ObstaclePoint[i].O_X
                                   + map.ObstaclePoint[i].O_width)
                    {
                        // Ver 1.0
                        //r.setAngle(r.angles[this.generateRandom()]);

                        // Ver 2.0 Sep 26,2013
                        //if (r.Angle % 90 != 0)
                        //{
                        //    r.setAngle(90);
                        //    break;
                        //}
                        r.setAngle(r.angles[this.generateRandom()]);
                        break;
                    }
                    //    // 机器人角度在0-90度
                    //    if (r.Angle >= 0 && r.Angle <= 90)
                    //    {
                    //        if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                    //            r.t[j].T_Y < map.ObstaclePoint[i].O_Y 
                    //                       + map.ObstaclePoint[i].O_height &&
                    //            r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                    //            r.t[j].T_X < map.ObstaclePoint[i].O_X
                    //                       + map.ObstaclePoint[i].O_width)
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            // Debug Sep 24,2013 16:07
                    //            //MessageBox.Show("障碍物的碰撞");
                    //        }
                    //    }
                    //    // 机器人角度在90-180度
                    //    if (r.Angle > 90 && r.Angle <= 180)
                    //    {
                    //        if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                    //            r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                    //                       + map.ObstaclePoint[i].O_height &&
                    //            r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                    //            r.t[j].T_X < map.ObstaclePoint[i].O_X
                    //                       + map.ObstaclePoint[i].O_width)
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            // Debug Sep 24,2013 16:07
                    //            //MessageBox.Show("障碍物的碰撞");
                    //        }
                    //    }
                    //    // 机器人角度在180-270度
                    //    if (r.Angle > 180 && r.Angle <= 270)
                    //    {
                    //        if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                    //            r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                    //                       + map.ObstaclePoint[i].O_height &&
                    //            r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                    //            r.t[j].T_X < map.ObstaclePoint[i].O_X
                    //                       + map.ObstaclePoint[i].O_width)
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            // Debug Sep 24,2013 16:07
                    //            //MessageBox.Show("障碍物的碰撞");
                    //        }
                    //    }
                    //    // 机器人角度在270-360度
                    //    if (r.Angle > 270 && r.Angle <= 360)
                    //    {
                    //        if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                    //            r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                    //                       + map.ObstaclePoint[i].O_height &&
                    //            r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                    //            r.t[j].T_X < map.ObstaclePoint[i].O_X
                    //                       + map.ObstaclePoint[i].O_width)
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            // Debug Sep 24,2013 16:07
                    //            //MessageBox.Show("障碍物的碰撞");
                    //        }
                    //    }
                }
            }
            // 墙壁的碰撞
            for (int i = 0; i < r.t.Length; i++)
            {
                if (r.t[i].T_X + r.get_step() <= 0 ||
                r.t[i].T_Y + r.get_step() <= 0 ||
                r.t[i].T_X - r.get_step() >= panel.Width ||
                r.t[i].T_Y - r.get_step() >= panel.Height)
                {

                    r.setAngle(r.angles[this.generateRandom()]);
                    break;

                    //if (r.Angle > 90 && r.Angle < 180)
                    //{
                    //r.setAngle(90);
                    //break;
                    //}
                    //else
                    //{
                    //    r.setAngle(r.angles[this.generateRandom()]);
                    //    break;
                    //}
                }
            }
            //if (r.get_R_X() <= 0 ||
            //    r.get_R_Y() <= 0 ||
            //    r.get_R_X() >= panel.Width ||
            //    r.get_R_Y() >= panel.Height)
            //{
            //    r.setAngle(r.angles[this.generateRandom()]);
            //}
            //else
            //{
            //    r.setAngle(0);
            //}

            //// 碰到右边 情况1
            //if (r.get_R_X() <=10 && r.Angle > 0 && r.Angle < 90)
            //{

            //}
            //// 碰到右边 情况2
            //if (r.get_R_Y() + r.R_Height <= panel.Height && r.Angle > 90 && r.Angle < 180)
            //{
            //    r.setAngle(15);
            //}
            //// 碰到右边 情况3
            //if (r.get_R_X() + r.R_Width <= panel.Width && r.Angle > 180 && r.Angle < 270)
            //{
            //    r.setAngle(15);
            //}
            //// 碰到右边 情况4
            //if (r.get_R_Y() - r.R_Height <= 0 && r.Angle > 270 && r.Angle < 360)
            //{
            //    r.setAngle(15);
            //}
        }
        /// <summary>
        /// 检测随机 碰撞和污浊区域
        /// </summary>
        /// <param name="map">地图</param>
        /// <param name="r">机器人</param>
        /// <param name="panel">Panel</param>
        private void checkCollideAndDirtyForStochastic(Map map, Robot r, Panel panel)
        {
            // 检测随机 污浊区域
            checkDirtyForStochastic(map, r, panel);
            // 检测随机 障碍物碰撞
            checkObstacleCollideForStochastic(map, r, panel);
            // 检测随机 墙壁碰撞
            checkWallCollideForStochastic(map, r, panel);
        }
        /// <summary>
        /// 检测右转的碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        /// <returns></returns>
        private void checkCollideForTurnRight(Map map, Robot r, Panel panel)
        {
            for (int i = 0; i < r.t.Length; i++)
            {
                if (r.t[i].T_X <= 0 ||
                r.t[i].T_Y <= 0 ||
                r.t[i].T_X >= panel.Width ||
                r.t[i].T_Y >= panel.Height)
                {
                    r.setAngle(-r.angles[this.generateRandom()]);
                }
                else
                {
                    r.setAngle(0);
                }
            }
        }
        /// <summary>
        /// 生成随机数
        /// </summary>
        /// <returns></returns>
        private int generateRandom()
        {
            Random gen = new Random();
            int ran = gen.Next(0, 12);
            //MessageBox.Show(ran.ToString());
            return ran / 12;
        }
        /// <summary>
        /// 机器人 清扫地面 沿边走
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanRound(Map map, Robot r, Panel panel)
        {
            // 检测沿障碍物转弯
            checkTurningForCleanRound(map, r, panel);
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人 清扫地面 S型
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanS(Map map, Robot r, Charger c, Panel panel)
        {
            // 机器人找充电座
            //if (!r.chargerHasFound)
            //{
            //    r.findCharger(r, c);
            //}
            //else // 找到充电座后，按照S型走
            //{
            robotGoByS(map, r, c, panel);
            //}
            // 画轨迹
            r.drawRobot(r, panel);
        }
        /// <summary>
        /// 机器人 按照S型行走
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="c"></param>
        /// <param name="panel"></param>
        private void robotGoByS(Map map, Robot r, Charger c, Panel panel)
        {
            // 检测碰撞
            checkCollide(map, r, panel);
            // 检测障碍物碰撞 Sep 22,2013 09:45
            checkObstacleCollideForS(map, r, panel);
            // 检测墙壁碰撞
            checkWallCollideForS(map, r, panel);
            // 机器人行走
            r.robotGoByAngle(r.Angle);
        }
        /// <summary>
        /// 检测S型 障碍物碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkObstacleCollideForS(Map map, Robot r, Panel panel)
        {
            // 遍历障碍物
            for (int i = 0; i < map.ObstaclePoint.Count; i++)
            {
                // 如果角度为0 (即水平向左)
                if (r.Angle == 0 &&
                     r.get_R_Y() + r.R_Height > map.ObstaclePoint[i].O_Y &&
                     r.get_R_X() - r.get_step() < map.ObstaclePoint[i].O_X + map.ObstaclePoint[i].O_width &&
                     r.get_R_Y() < map.ObstaclePoint[i].O_Y + map.ObstaclePoint[i].O_height
                    )
                {
                    //if (r.besides_left == true)
                    //{
                    // 逆时针90度
                    r.setAngle(90);
                    // 设置机器人已经靠左
                    r.besides_left = true;
                    //}
                }
                //// 如果角度为90
                if (r.Angle == 90)
                {
                    //if (r.besides_left)
                    //{
                    //    if (r.SGoStep < r.R_Height)
                    //    {
                    //        if (r.get_R_X() + r.get_step() > r.R_Height)
                    //        {
                    //            r.SGoStep += r.get_step() / 8;
                    //        }
                    //        else
                    //        {
                    //            r.SGoStep += r.get_step();
                    //        }
                    //    }
                    //    else
                    //    {
                    //        // Debug
                    //        //MessageBox.Show(r.SGoStep.ToString());

                    //        // 机器人转向 逆时针90度
                    //        //r.setAngle(90);
                    //        r.SGoInit();
                    //    }
                    //}
                    //else
                    //{
                    //    if (r.SGoStep < r.R_Height)
                    //    {
                    //        r.SGoStep += r.get_step();
                    //    }
                    //    else
                    //    {
                    //        // Debug
                    //        MessageBox.Show(r.SGoStep.ToString());

                    //        // 机器人转向 顺时针90度
                    //        //r.setAngle(-90);
                    //        // 设置机器人靠左
                    //        r.besides_left = true;
                    //        r.SGoInit();
                    //    }
                    //}
                }
                //如果角度为180
                if (r.Angle == 180 &&
                    r.get_R_Y() + r.R_Height > map.ObstaclePoint[i].O_Y &&
                    r.get_R_Y() > map.ObstaclePoint[i].O_Y &&
                    r.get_R_X() + r.R_Width + r.get_step() > map.ObstaclePoint[i].O_X)
                {
                    //r.setAngle(-90);
                    // 设置机器人不靠左
                    r.besides_left = false;
                    r.SGoInit();
                }
            }
        }
        /// <summary>
        /// 检测S型碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        /// <returns></returns>
        private void checkCollide(Map map, Robot r, Panel panel)
        {
            if (r.get_R_Y() + r.R_Height <= panel.Height)
            {
                // 检测到碰撞 : 左右一起碰 正方向
                if ((r.get_R_X() < 10 && r.Angle == 0))
                {
                    // 逆时针增量 90度
                    r.setAngle(90);
                    // 设置机器人已经靠左
                    r.besides_left = true;
                }
                //// 检测到碰撞 : 左右一起碰 反方向
                //if (r.get_R_X() > panel.Width && r.Angle == 180)
                //{
                //    // 顺时针增量 90度
                //    r.setAngle(-90);
                //}
                //// 如果已经是90度方向行进了
                if (r.Angle == 90)
                {
                    if (r.besides_left)
                    {
                        if (r.SGoStep < r.R_Height)
                        {
                            if (r.get_R_X() + r.get_step() > r.R_Height)
                            {
                                r.SGoStep += r.get_step();
                            }
                            else
                            {
                                r.SGoStep += r.get_step();
                            }
                        }
                        else
                        {
                            // Debug
                            //MessageBox.Show(r.SGoStep.ToString());

                            // 机器人转向 逆时针90度
                            r.setAngle(90);
                            r.SGoInit();
                        }
                    }
                    else
                    {
                        if (r.SGoStep < r.R_Height)
                        {
                            r.SGoStep += r.get_step();
                        }
                        else
                        {
                            // Debug
                            //MessageBox.Show(r.SGoStep.ToString());

                            // 机器人转向 顺时针90度
                            r.setAngle(-90);
                            // 设置机器人靠左
                            r.besides_left = true;
                            r.SGoInit();
                        }
                    }
                }
                // 如果已经是180度方向行进了
                if (r.Angle == 180)
                {
                    if (r.get_R_X() + r.R_Width + r.get_step() <= panel.Width)
                    {
                        r.SGoStep += r.get_step();
                    }
                    else
                    {
                        // 机器人转向 顺时针90度
                        r.setAngle(-90);
                        // 设置机器人不靠左
                        r.besides_left = false;
                        r.SGoInit();
                    }
                }
            }
            else // 沿着S型清扫完毕
            {
                // 转变模式为沿墙壁打扫
                r.R_RUN_MODE = 0;
            }
            //if (r.R_RUN_MODE == 0)
            //{
            //    // 沿墙壁检测
            //    checkCollideForWall(map, r, panel);
            //}
        }
        /// <summary>
        /// 检测S型 沿墙碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        /// <returns></returns>
        private void checkWallCollideForS(Map map, Robot r, Panel panel)
        {
            // 检测到碰撞 : 左右一起碰 正方向
            if ((r.get_R_X() < 10 && r.Angle == 0))
            {
                // 逆时针增量 90度
                r.setAngle(90);
            }
            // 检测到碰撞 : 左右一起碰 反方向
            if (r.get_R_X() > panel.Width && r.Angle == 180)
            {
                // 顺时针增量 90度
                r.setAngle(-90);
            }
            // 如果已经是90度方向行进了
            if (r.Angle == 90)
            {

            }
            if ((r.get_R_Y() + r.R_Height >= panel.Height)
                && r.Angle == 90)
            {
                r.setAngle(90);
            }
            if ((r.get_R_X() + r.R_Width >= panel.Width)
                && r.Angle == 180)
            {
                r.setAngle(90);
            }
            if ((r.get_R_Y() - r.get_step() < 0)
                && r.Angle == 270)
            {
                r.setAngle(-270);
            }
            //// 检测到碰撞 : 左碰
            //if (r.Angle == 0 && r.Angle < 90)
            //{
            //    r.setAngle(90);
            //}
            //// 检测到碰撞 : 右碰
            //if (r.Angle == 0 && r.Angle < 90)
            //{
            //    r.setAngle(90);
            //}
        }
        /// <summary>
        /// 机器人 清扫地面 随机
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        public void robotCleanStochastic(Map map, Robot r, Panel panel)
        {/*  检测随机碰撞 V1.0
            //Random gen = new Random();
            //int ran = gen.Next(-10,10);
            //r.set_R_X(ran +1);
            //r.set_R_Y(ran - 4);
            //drawEllipse(r,panel);
            Random gen = new Random();
            int ran = gen.Next(-180, 180);
            r.robotGoByAngle(ran);
            r.drawRobot(r, panel);
          */
            // 检测随机碰撞 V2.0
            robotGoByStochastic(map, r, panel);
            // 画机器人
            r.drawRobot(r, panel);
            if (r.CollideCount < 1000)
            {
                //Nothing to do here
            }
            else
            {
                // 设置沿墙模式
                r.R_RUN_MODE = 0;
                // 碰撞次数清零
                r.CollideCount = 0;
            }
        }
        /// <summary>
        /// 机器人 清扫地面 顺时针回型
        /// </summary>
        public void robotCleanClockwise(Map map, Robot r, Panel panel)
        {
            switch (r.get_direction())
            {
                case 1:
                    //顺时针右
                    right(map, r, panel);
                    break;
                case 2:
                    //顺时针下
                    down(map, r, panel);
                    break;
                case 3:
                    //顺时针左
                    left(map, r, panel);
                    break;
                case 4:
                    //顺时针上
                    up(map, r, panel);
                    break;
                case 5:
                    //逆时针右
                    _right(map, r, panel);
                    break;
                case 6:
                    //逆时针下
                    _down(map, r, panel);
                    break;
                case 7:
                    //逆时针左
                    _left(map, r, panel);
                    break;
                case 8:
                    //逆时针上
                    _up(map, r, panel);
                    break;
                default:
                    break;
            }
        }
        #endregion
        #region 清扫检测
        /// <summary>
        /// 检测随机 污浊区域
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkDirtyForStochastic(Map map, Robot r, Panel panel)
        {
            // 检测污浊区域
            for (int k = 0; k < map.DirtyPoint.Count; k++)
            {
                for (int m = 0; m < r.t.Length; m++)
                {
                    if (r.t[m].T_Y > map.DirtyPoint[k].D_Y &&
                        r.t[m].T_Y < map.DirtyPoint[k].D_Y
                                   + map.DirtyPoint[k].D_Height &&
                        r.t[m].T_X > map.DirtyPoint[k].D_X &&
                        r.t[m].T_X < map.DirtyPoint[k].D_X
                                   + map.DirtyPoint[k].D_Width)
                    {
                        r.HasDetectedDirty = true;
                        r.R_RUN_MODE = 6;
                        //return;
                        MessageBox.Show("此地污浊！重点打扫。");
                    }
                }
            }
        }
        /// <summary>
        /// 检测随机 障碍物碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkObstacleCollideForStochastic(Map map, Robot r, Panel panel)
        {
            // 障碍物的碰撞
            for (int i = 0; i < map.ObstaclePoint.Count; i++)
            {
                for (int j = 0; j < r.t.Length; j++)
                {
                    //================Version 02=========================
                    if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                        r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                                   + map.ObstaclePoint[i].O_height &&
                        r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                        r.t[j].T_X < map.ObstaclePoint[i].O_X
                                   + map.ObstaclePoint[i].O_width)
                    {
                        // 碰撞障碍物 左边
                        if (r.get_Center_X_Y().X <= map.ObstaclePoint[i].O_X)
                        {
                            if (r.Angle > 180 && r.Angle < 195)
                            {
                                r.setAngle(r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle >= 195 && r.Angle < 225)
                            {
                                r.setAngle(r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle >= 225 && r.Angle <= 270)
                            {
                                r.setAngle(r.AnglesForStochastic[2]);
                                break;
                            }
                            if (r.Angle > 165 && r.Angle <= 180)
                            {
                                r.setAngle(-r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle > 135 && r.Angle <= 165)
                            {
                                r.setAngle(-r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle > 90 && r.Angle <= 135)
                            {
                                r.setAngle(-r.AnglesForStochastic[2]);
                                break;
                            }
                        }
                        // 碰撞障碍物 右边
                        if (r.get_Center_X_Y().X >=
                            map.ObstaclePoint[i].O_X + map.ObstaclePoint[i].O_width)
                        {
                            if (r.Angle >= 0 && r.Angle < 15)
                            {
                                r.setAngle(r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle >= 15 && r.Angle < 45)
                            {
                                r.setAngle(r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle >= 45 && r.Angle < 90)
                            {
                                r.setAngle(r.AnglesForStochastic[2]);
                                break;
                            }
                            if (r.Angle > 270 && r.Angle < 285)
                            {
                                r.setAngle(-r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle >= 285 && r.Angle < 315)
                            {
                                r.setAngle(-r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle >= 315 && r.Angle < 360)
                            {
                                r.setAngle(-r.AnglesForStochastic[2]);
                                break;
                            }
                        }
                        // 碰撞障碍物 上边
                        if (r.get_Center_X_Y().Y <= map.ObstaclePoint[i].O_Y)
                        {
                            if (r.Angle > 75 && r.Angle <= 90)
                            {
                                r.setAngle(-r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle > 45 && r.Angle <= 75)
                            {
                                r.setAngle(-r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle > 0 && r.Angle <= 45)
                            {
                                r.setAngle(-r.AnglesForStochastic[2]);
                                break;
                            }
                            if (r.Angle > 90 && r.Angle < 115)
                            {
                                r.setAngle(r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle >= 115 && r.Angle < 135)
                            {
                                r.setAngle(r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle >= 135 && r.Angle < 180)
                            {
                                r.setAngle(r.AnglesForStochastic[2]);
                                break;
                            }
                        }
                        // 碰撞障碍物 下边
                        if (r.get_Center_X_Y().Y >=
                            map.ObstaclePoint[i].O_Y + map.ObstaclePoint[i].O_height)
                        {
                            if (r.Angle > 255 && r.Angle <= 270)
                            {
                                r.setAngle(-r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle > 225 && r.Angle <= 255)
                            {
                                r.setAngle(-r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle > 180 && r.Angle <= 225)
                            {
                                r.setAngle(-r.AnglesForStochastic[2]);
                                break;
                            }
                            if (r.Angle > 270 && r.Angle < 285)
                            {
                                r.setAngle(r.AnglesForStochastic[0]);
                                break;
                            }
                            if (r.Angle >= 285 && r.Angle < 315)
                            {
                                r.setAngle(r.AnglesForStochastic[1]);
                                break;
                            }
                            if (r.Angle >= 315 && r.Angle < 360)
                            {
                                r.setAngle(r.AnglesForStochastic[2]);
                                break;
                            }
                        }
                    }
                    //================Version 01=========================
                    //if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                    //    r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                    //               + map.ObstaclePoint[i].O_height &&
                    //    r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                    //    r.t[j].T_X < map.ObstaclePoint[i].O_X
                    //               + map.ObstaclePoint[i].O_width)
                    //{
                    //    r.setAngle(r.angles[this.generateRandom()]);
                    //    //while (r.t[j].T_X + 
                    //    //    r.get_step() *  Math.Sin(r.Angle + 15) > )
                    //    //{
                    //    //    r.setAngle(15);   
                    //    //}
                    //}
                    //===================================================
                }
            }
        }
        /// <summary>
        /// 检测随机 墙壁碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkWallCollideForStochastic(Map map, Robot r, Panel panel)
        {
            //if (r.Angle % 90 == 0)
            //{
            //    r.setAngle(30);
            //    return;
            //}
            //int index = this.generateRandom();
            // 墙壁的碰撞
            for (int i = 0; i < r.t.Length; i++)
            {
                if (r.t[i].T_X + r.get_step() <= 0 ||
                    r.t[i].T_Y + r.get_step() <= 0 ||
                    r.t[i].T_X - r.get_step() / 2 >= panel.Width ||
                    r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                {
                    // 碰到 左边的边
                    if (r.t[i].T_X + r.get_step() <= 0)
                    {
                        // 碰撞次数自增
                        r.CollideCount++;
                        // 第三象限
                        if (r.Angle >= 0 && r.Angle < 15)
                        {
                            r.setAngle(r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle >= 15 && r.Angle < 30)
                        {
                            r.setAngle(r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle >= 30 && r.Angle < 45)
                        {
                            r.setAngle(r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle >= 45 && r.Angle < 60)
                        {
                            r.setAngle(r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle >= 60 && r.Angle < 75)
                        {
                            r.setAngle(r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle >= 75 && r.Angle <= 90)
                        {
                            r.setAngle(r.AnglesForStochastic[5]);
                            break;
                        }
                        // 第二象限
                        if (r.Angle >= 270 && r.Angle < 285)
                        {
                            r.setAngle(-r.AnglesForStochastic[5]);
                            break;
                        }
                        if (r.Angle >= 285 && r.Angle < 300)
                        {
                            r.setAngle(-r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle >= 300 && r.Angle < 315)
                        {
                            r.setAngle(-r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle >= 315 && r.Angle < 330)
                        {
                            r.setAngle(-r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle >= 330 && r.Angle < 345)
                        {
                            r.setAngle(-r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle >= 345 && r.Angle <= 360)
                        {
                            r.setAngle(-r.AnglesForStochastic[0]);
                            break;
                        }
                    }
                    // 碰到 右边的边
                    if (r.t[i].T_X - r.get_step() / 2 >= panel.Width)
                    {
                        // 碰撞次数自增
                        r.CollideCount++;
                        // 第一象限
                        if (r.Angle > 180 && r.Angle < 195)
                        {
                            r.setAngle(r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle >= 195 && r.Angle < 210)
                        {
                            r.setAngle(r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle >= 210 && r.Angle < 225)
                        {
                            r.setAngle(r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle >= 225 && r.Angle < 240)
                        {
                            r.setAngle(r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle >= 240 && r.Angle < 255)
                        {
                            r.setAngle(r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle >= 255 && r.Angle <= 270)
                        {
                            r.setAngle(r.AnglesForStochastic[5]);
                            break;
                        }
                        // 第四象限
                        if (r.Angle > 165 && r.Angle <= 180)
                        {
                            r.setAngle(-r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle > 150 && r.Angle <= 165)
                        {
                            r.setAngle(-r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle > 135 && r.Angle <= 150)
                        {
                            r.setAngle(-r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle > 120 && r.Angle <= 135)
                        {
                            r.setAngle(-r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle > 105 && r.Angle <= 120)
                        {
                            r.setAngle(-r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle > 90 && r.Angle <= 105)
                        {
                            r.setAngle(-r.AnglesForStochastic[5]);
                            break;
                        }
                    }
                    // 碰到 上边的边
                    if (r.t[i].T_Y + r.get_step() <= 0)
                    {
                        // 碰撞次数自增
                        r.CollideCount++;
                        // 第三象限
                        if (r.Angle > 255 && r.Angle <= 270)
                        {
                            r.setAngle(-r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle > 240 && r.Angle <= 255)
                        {
                            r.setAngle(-r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle > 225 && r.Angle <= 240)
                        {
                            r.setAngle(-r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle > 210 && r.Angle <= 225)
                        {
                            r.setAngle(-r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle > 195 && r.Angle <= 210)
                        {
                            r.setAngle(-r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle > 180 && r.Angle <= 195)
                        {
                            r.setAngle(-r.AnglesForStochastic[5]);
                            break;
                        }
                        // 第四象限
                        if (r.Angle > 270 && r.Angle < 285)
                        {
                            r.setAngle(r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle >= 285 && r.Angle < 300)
                        {
                            r.setAngle(r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle >= 300 && r.Angle < 315)
                        {
                            r.setAngle(r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle >= 315 && r.Angle < 330)
                        {
                            r.setAngle(r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle >= 330 && r.Angle < 345)
                        {
                            r.setAngle(r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle >= 345 && r.Angle < 360)
                        {
                            r.setAngle(r.AnglesForStochastic[5]);
                            break;
                        }
                    }
                    // 碰到 下边的边
                    if (r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                    {
                        // 碰撞次数自增
                        r.CollideCount++;
                        // 第三象限
                        if (r.Angle > 75 && r.Angle <= 90)
                        {
                            r.setAngle(-r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle > 60 && r.Angle <= 75)
                        {
                            r.setAngle(-r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle > 45 && r.Angle <= 60)
                        {
                            r.setAngle(-r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle > 30 && r.Angle <= 45)
                        {
                            r.setAngle(-r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle > 15 && r.Angle <= 30)
                        {
                            r.setAngle(-r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle > 0 && r.Angle <= 15)
                        {
                            r.setAngle(-r.AnglesForStochastic[5]);
                            break;
                        }
                        // 第四象限
                        if (r.Angle > 90 && r.Angle < 105)
                        {
                            r.setAngle(r.AnglesForStochastic[0]);
                            break;
                        }
                        if (r.Angle >= 105 && r.Angle < 120)
                        {
                            r.setAngle(r.AnglesForStochastic[1]);
                            break;
                        }
                        if (r.Angle >= 120 && r.Angle < 135)
                        {
                            r.setAngle(r.AnglesForStochastic[2]);
                            break;
                        }
                        if (r.Angle >= 135 && r.Angle < 150)
                        {
                            r.setAngle(r.AnglesForStochastic[3]);
                            break;
                        }
                        if (r.Angle >= 150 && r.Angle < 165)
                        {
                            r.setAngle(r.AnglesForStochastic[4]);
                            break;
                        }
                        if (r.Angle >= 165 && r.Angle < 180)
                        {
                            r.setAngle(r.AnglesForStochastic[5]);
                            break;
                        }
                    }


                    ////0-90  270-360
                    ////if (Math.Abs(r.Angle - 180) >= 90)
                    ////{
                    ////    if (r.t[i].T_X + r.get_step() <= 0)
                    ////    {
                    ////        if (Math.Abs(r.Angle - 180) >= 165)
                    ////        {
                    ////            r.setAngle(BiggerThan(r.Angle, 0) * 90);
                    ////            //MessageBox.Show("r.setAngle(BiggerThan(r.Angle, 0) * 90);");
                    ////        }
                    ////        else if (Math.Abs(r.Angle - 180) >= 135)
                    ////        {
                    ////            r.setAngle(BiggerThan(r.Angle, 0) * 80);
                    ////        }
                    ////        else if (Math.Abs(r.Angle - 180) >= 90)
                    ////        {
                    ////            r.setAngle(BiggerThan(r.Angle, 0) * 70);
                    ////        }
                    ////        else
                    ////        {
                    ////            r.setAngle(r.angles[this.generateRandom()]);
                    ////            break;
                    ////        }
                    ////    }
                    ////else
                    ////{
                    ////    r.setAngle(r.angles[this.generateRandom()]);
                    ////    break;
                    ////}
                    ////}
                    ////180-360
                    //if ((Math.Abs(r.Angle - 270) <= 90))
                    //{
                    //    if (r.t[i].T_Y + r.get_step() <= 0)
                    //    {
                    //        if (Math.Abs(r.Angle - 270) <= 15)
                    //        {
                    //            r.setAngle(BiggerThan(r.Angle - 270, 0) * 90);
                    //        }
                    //        else if (Math.Abs(r.Angle - 270) <= 45)
                    //        {
                    //            r.setAngle(BiggerThan(r.Angle - 270, 0) * 100);
                    //        }
                    //        else if (Math.Abs(r.Angle - 270) <= 90)
                    //        {
                    //            r.setAngle(BiggerThan(r.Angle - 270, 0) * 110);
                    //        }
                    //        else
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            break;
                    //        }
                    //    }
                    //    else
                    //    {
                    //        r.setAngle(r.angles[this.generateRandom()]);
                    //        break;
                    //    }
                    //}
                    ////0-180
                    //if ((Math.Abs(r.Angle - 90) <= 90))
                    //{
                    //    if (r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                    //    {
                    //        if (Math.Abs(r.Angle - 90) <= 15)
                    //        {
                    //            r.setAngle(this.BiggerThan(r.Angle - 90, 90) * (r.Angle + 180 + 2 * Math.Abs(r.Angle - 90)));
                    //            //r.setAngle(-2*r.Angle);
                    //            //MessageBox.Show(
                    //            //"r.setAngle(r.Angle + 180 -Math.Abs(r.Angle-90));");
                    //            break;
                    //        }
                    //        //else if (Math.Abs(r.Angle - 90) <= 45)
                    //        //{
                    //        //    r.setAngle(BiggerThan(r.Angle - 90, 90) * Math.Abs(180 - r.Angle));
                    //        //    break;
                    //        //}
                    //        //else if (Math.Abs(r.Angle - 90) <= 90)
                    //        //{
                    //        //    r.setAngle(BiggerThan(r.Angle - 90, 90) * Math.Abs(180 - r.Angle));
                    //        //    break;
                    //        //}
                    //        else
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            break;
                    //        }
                    //    }
                    //    //else
                    //    //{
                    //    //    r.setAngle(r.angles[this.generateRandom()]);
                    //    //    break;
                    //    //}
                    //}
                    ////90-270
                    //if (Math.Abs(r.Angle - 180) >= 90)
                    //{
                    //    if (r.t[i].T_X - r.get_step() / 2 >= panel.Width)
                    //    {
                    //        if (Math.Abs(r.Angle - 180) <= 15)
                    //        {
                    //            r.setAngle(BiggerThan(r.Angle - 180, 180) * 90);
                    //            MessageBox.Show("r.setAngle(BiggerThan(r.Angle - 180, 180) * 90);");
                    //        }
                    //        else if (Math.Abs(r.Angle - 180) <= 45)
                    //        {
                    //            r.setAngle(BiggerThan(180, r.Angle - 180) * 100);
                    //            MessageBox.Show("r.setAngle(BiggerThan(r.Angle - 180, 180) * 100);");
                    //        }
                    //        else if (Math.Abs(r.Angle - 180) <= 90)
                    //        {
                    //            r.setAngle(BiggerThan(r.Angle - 180, 180) * 30);
                    //        }
                    //        else
                    //        {
                    //            r.setAngle(r.angles[this.generateRandom()]);
                    //            break;
                    //        }
                    //    }
                    //    //else
                    //    //{
                    //    //    r.setAngle(r.angles[this.generateRandom()]);
                    //    //    break;
                    //    //}
                    //}
                    //The below is old version02 ======================
                    //if (r.t[i].T_X + r.get_step() <= 0 && Math.Abs(r.Angle - 180) >= 90)
                    //{
                    //    //if (r.t[i].T_Y - r.get_step() / 2 >= panel.Height && (Math.Abs(r.Angle - 90) <= 90))
                    //    //{
                    //    //    if (r.t[i].T_X + r.get_step() <= 0)
                    //    //    {
                    //    //        r.setAngle(90);
                    //    //        MessageBox.Show("左下角");
                    //    //        continue;
                    //    //    }
                    //    //}
                    //    if (Math.Abs(r.Angle - 180) >= 165)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle, 0) * 90);
                    //    }
                    //    else if (Math.Abs(r.Angle - 180) >= 135)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle, 0) * 60);
                    //    }
                    //    else if (Math.Abs(r.Angle - 180) >= 90)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle, 0) * 30);
                    //    }
                    //    else
                    //    {
                    //        r.setAngle(r.angles[this.generateRandom()]);
                    //    }
                    //    break;
                    //}
                    //if (r.t[i].T_Y + r.get_step() <= 0 && (Math.Abs(r.Angle - 270) <= 90))
                    //{
                    //    if (Math.Abs(r.Angle - 270) <=15)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 270,0) * 90);
                    //    }
                    //    else if (Math.Abs(r.Angle - 270) <= 45)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 270, 0) * 60);
                    //    }
                    //    else if (Math.Abs(r.Angle - 270) <= 90)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 270, 0) * 30);
                    //    }
                    //    else
                    //    {
                    //        r.setAngle(r.angles[this.generateRandom()]);
                    //    }
                    //    break;
                    //}
                    //if (r.t[i].T_X - r.get_step() / 2 >= panel.Width)
                    //{
                    //    if (Math.Abs(r.Angle - 180) <= 15)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 180, 0) * 90);
                    //    }
                    //    else if (Math.Abs(r.Angle - 180) <= 45)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 180, 0) * 60);
                    //    }
                    //    else if (Math.Abs(r.Angle - 180) <= 90)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 180, 0) * 30);
                    //    }
                    //    else
                    //    {
                    //        r.setAngle(r.angles[this.generateRandom()]);
                    //    }
                    //    break;
                    //}
                    //if (r.t[i].T_Y - r.get_step() / 2 >= panel.Height && (Math.Abs(r.Angle - 90) <= 90))
                    //{
                    //    //if (r.t[i].T_X + r.get_step() <= 0)
                    //    //{
                    //    //    r.setAngle(90);
                    //    //    MessageBox.Show("左下角");
                    //    //    continue;
                    //    //}
                    //    if (Math.Abs(r.Angle - 90) <= 15)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 90, 90) * 90);
                    //        break;
                    //    }
                    //    else if (Math.Abs(r.Angle - 90) <= 45)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 90, 90) * 60);
                    //        break;
                    //    }
                    //    else if (Math.Abs(r.Angle - 90) <= 90)
                    //    {
                    //        r.setAngle(BiggerThan(r.Angle - 90, 90) * 30);
                    //        break;
                    //    }
                    //    else
                    //    {
                    //        r.setAngle(r.angles[this.generateRandom()]);
                    //    }
                    //    break;
                    //}
                    //The below is old version01 ======================
                    //if (r.t[i].T_X + r.get_step() <= 0 ||
                    //    r.t[i].T_Y + r.get_step() <= 0 ||
                    //    r.t[i].T_X - r.get_step() / 2 >= panel.Width ||
                    //    r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                    //{

                    //MessageBox.Show("检测随机碰撞");
                    //r.setAngle(analyzer.Analyze(1, 1, new int[] { 1, 0, 0, 0, 0 }));

                    //r.setAngle(r.angles[index]);

                    //if (r.Analyze.NodeCount == 1)
                    //{
                    //    // 如果已经有一个节点，那么要增加的第二个节点的X值就是步数，Y值为零,Degree为零
                    //    r.Analyze.AddNode(0, r.R_LineStep * r.get_step(), r.R_LineStep * r.get_step(), 0);
                    //}
                    //else if (r.Analyze.NodeCount == 2)
                    //{
                    //    // 如果已经有两个节点，那么要增加的第三个节点的X值就是步数，
                    //    r.Analyze.AddNode(r.angles[index], r.R_LineStep * r.get_step(), r.R_LineStep * r.get_step(), 0);
                    //}
                    //else
                    //{
                    //    r.Analyze.AddNode(r.angles[index], r.R_LineStep * r.get_step(),
                    //        r.Analyze.LastPoint.X + r.R_LineStep * r.get_step() * (int)Math.Cos((r.angles[index] + r.Analyze.LastDegree) * Math.PI / 180),
                    //        r.Analyze.LastPoint.Y + r.R_LineStep * r.get_step() * (int)Math.Sin((r.angles[index] + r.Analyze.LastDegree) * Math.PI / 180));
                    //}
                    //// 机器人的步数清零
                    //r.R_LineStepClear();
                    ////break;
                    //}
                }
            }

        }
        /// <summary>
        /// 倒退清扫 障碍物的碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkObstacleCollideForCleanBackwards(Map map, Robot r, Panel panel)
        {
            for (int i = 0; i < map.ObstaclePoint.Count; i++)
            {
                for (int j = 0; j < r.t.Length; j++)
                {
                    if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                        r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                                   + map.ObstaclePoint[i].O_height &&
                        r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                        r.t[j].T_X < map.ObstaclePoint[i].O_X
                                   + map.ObstaclePoint[i].O_width)
                    {
                        // 碰到障碍物退出清扫循环 变随机模式
                        r.R_RUN_MODE = -1;
                        // 反向
                        r.setAngle(180);
                    }
                }
            }
        }
        /// <summary>
        /// 倒退清扫 墙壁的碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkWallCollideForCleanBackwards(Map map, Robot r, Panel panel)
        {
            for (int i = 0; i < r.t.Length; i++)
            {
                if (r.t[i].T_X + r.get_step() / 2 <= 0 ||
                    r.t[i].T_Y + r.get_step() / 2 <= 0 ||
                    r.t[i].T_X - r.get_step() / 2 >= panel.Width ||
                    r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                {
                    // 碰到障碍物退出清扫循环 变随机模式
                    r.R_RUN_MODE = -1;
                    // 反向
                    r.setAngle(180);
                }
            }
        }
        /// <summary>
        /// 检测沿墙 障碍物碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkObstacleCollideForWall(Map map, Robot r, Panel panel)
        {
            // 障碍物的碰撞
            for (int i = 0; i < map.ObstaclePoint.Count; i++)
            {
                for (int j = 0; j < r.t.Length; j++)
                {
                    if (r.t[j].T_Y > map.ObstaclePoint[i].O_Y &&
                        r.t[j].T_Y < map.ObstaclePoint[i].O_Y
                                   + map.ObstaclePoint[i].O_height &&
                        r.t[j].T_X > map.ObstaclePoint[i].O_X &&
                        r.t[j].T_X < map.ObstaclePoint[i].O_X
                                   + map.ObstaclePoint[i].O_width)
                    {
                        // Version 01
                        //r.setAngle(r.angles[this.generateRandom()]);
                        // Version 02

                        if (r.Angle == 90)
                        {
                            r.setAngle(90);
                        }
                        else
                        {
                            r.setAngle(r.angles[this.generateRandom()]);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 检测沿墙 墙壁碰撞
        /// </summary>
        /// <param name="map"></param>
        /// <param name="r"></param>
        /// <param name="panel"></param>
        private void checkWallCollideForWall(Map map, Robot r, Panel panel)
        {
            if (r.AnglesRound > 360)
            {
                r.CleanWallFinished = true;
            }
            // =============Version 02=============================
            for (int i = 0; i < r.t.Length; i++)
            {
                if (r.t[i].T_X + r.get_step() / 2 <= 0 ||
                    r.t[i].T_Y + r.get_step() / 2 <= 0 ||
                    r.t[i].T_X - r.get_step() / 2 >= panel.Width ||
                    r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                {
                    // 单独处理原点
                    if (r.t[i].T_X - r.get_step() / 2 <= 0 &&
                        r.t[i].T_Y - r.get_step() / 2 <= 0)
                    {
                        r.setAngle(90);
                        // 增加环绕角度
                        r.AnglesRound += 90;
                        break;
                    }
                    // 碰到 左边的边
                    if (r.t[i].T_X - r.get_step() / 2 <= 0)
                    {
                        if (r.Angle >= 0 && r.Angle < 90)
                        {
                            r.setAngle(90 - r.Angle);
                            // 增加环绕角度
                            r.AnglesRound += 90;
                            break;
                        }
                        if (r.Angle > 270 && r.Angle < 360)
                        {
                            r.setAngle(450 - r.Angle);
                            // 增加环绕角度
                            r.AnglesRound += 90;
                            break;
                        }
                    }
                    // 碰到 右边的边
                    if (r.t[i].T_X - r.get_step() / 2 >= panel.Width)
                    {
                        if (r.Angle > 90 && r.Angle < 270)
                        {
                            r.setAngle(270 - r.Angle);
                            // 增加环绕角度
                            r.AnglesRound += 90;
                            break;
                        }
                    }
                    // 碰到 上边的边
                    if (r.t[i].T_Y + r.get_step() <= 0)
                    {
                        if (r.Angle > 180 && r.Angle < 360)
                        {
                            r.setAngle(360 - r.Angle);
                            // 增加环绕角度
                            r.AnglesRound += 90;
                            break;
                        }
                    }
                    // 碰到 下边的边
                    if (r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
                    {
                        if (r.Angle > 0 && r.Angle < 180)
                        {
                            r.setAngle(180 - r.Angle);
                            // 增加环绕角度
                            r.AnglesRound += 90;
                            break;
                        }//If
                    }//If
                }//If
            }//For

            // =============Version 01=============================
            //// 墙壁的碰撞
            //for (int i = 0; i < r.t.Length; i++)
            //{
            //    if (r.t[i].T_X + r.get_step() <= 0 ||
            //    r.t[i].T_Y + r.get_step() <= 0 ||
            //    r.t[i].T_X - r.get_step() >= panel.Width ||
            //    r.t[i].T_Y - r.get_step() >= panel.Height)
            //    {
            //        if (r.Angle % 90 == 0)
            //        {
            //            r.setAngle(90);
            //            r.CleanWallAngle += 90;
            //            if (r.CleanWallAngle == 360)
            //            {
            //                //MessageBox.Show("r.CleanWallFinished = true;");
            //                r.CleanWallFinished = true;
            //                break;
            //            }
            //        }
            //        //else
            //        //{
            //        //    r.setAngle(r.angles[this.generateRandom()]);
            //        //}
            //        if (r.t[i].T_Y - r.get_step() / 2 >= panel.Height)
            //        {
            //            r.set_R_Y(-r.get_step());
            //            break;
            //        }
            //        if (r.t[i].T_X - r.get_step() / 2 >= panel.Width)
            //        {
            //            r.set_R_X(-r.get_step());
            //            break;
            //        }
            //    }//if
            //}//For
            // =====================================================
        }//Method
        #endregion d
        #region 画轨迹
        /// <summary>
        /// 画机器人路线轨迹
        /// </summary>
        //private void drawEllipse(Robot r,Panel panel1)
        //{
        //    try
        //    {
        //        using (Graphics g = panel1.CreateGraphics())
        //        {
        //            g.FillEllipse(new SolidBrush(r.R_Path_Color),
        //                                 r.get_R_X(), r.get_R_Y(),
        //                                 r.R_Width, r.R_Height);

        //            g.FillEllipse(new SolidBrush(r.R_Center_Color),
        //                                 r.get_R_X() + r.R_Width / 3, r.get_R_Y() + r.R_Height / 3,
        //                                 r.R_Width / 3, r.R_Height / 3);
        //            //g.FillPie(new SolidBrush(r.R_Center_Color),
        //            //                     r.get_R_X() + r.R_Width / 3, r.get_R_Y() + r.R_Height / 3,
        //            //                     r.R_Width / 3, r.R_Height / 3,30,-60);
        //            //g.DrawEllipse(new Pen(r.R_Path_Color),
        //            //                     r.get_R_X(), r.get_R_Y(),
        //            //                     r.R_Width, r.R_Height);
        //            //g.DrawEllipse(new Pen(r.R_Center_Color),
        //            //                     r.get_R_X() + r.R_Width / 3, r.get_R_Y() + r.R_Height / 3,
        //            //                     r.R_Width / 3, r.R_Height / 3);
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        MessageBox.Show(e.Message);
        //    }
        //}
        #endregion
        #region 机器人顺时针方向移动
        /// <summary>
        /// 机器人顺时针向右移动
        /// </summary>
        private void right(Map map, Robot r, Panel panel1/*,RichTextBox richTextBox*/)
        {
            int temp_width = panel1.Size.Width;
            // 如果没有原点节点 增加一个
            if (map.CleanAreaPoint.Count < 1)
            {
                map.CleanAreaPoint.Add(new Point(r.get_R_X(), r.get_R_Y() + r.R_Height - r.Ini_R_Y));
                //// debug
                //this.richTextBox1.Text += "Point1：(" + r.get_R_X() + "," + r.get_R_Y() + ")";
            }
            // 模拟寻找右边墙壁过程
            if (r.get_R_X() + r.R_Width < panel1.Size.Width)
            {
                r.drawRobot(r, panel1);  // 画轨迹
                r.set_R_X(r.get_step()); // 增加步长
                // 第一次记录下右上方节点
                if (map.CleanAreaPoint.Count < 2 && r.get_R_X() + r.R_Width >= temp_width)
                {
                    map.CleanAreaPoint.Add(new Point(r.get_R_X() + r.Ini_R_X, r.get_R_Y() + r.R_Height));
                    // debug
                    //this.richTextBox1.Text += "\nPoint2：(" + (r.get_R_X() - r.R_Width).ToString()
                    //                          + "," + (r.get_R_Y() + r.R_Height).ToString() + ")";

                    //cleanDebug.outputDebug(richTextBox, r);
                }
                if (map.CleanAreaPoint.Count >= 4)
                {
                    //MessageBox.Show("map.CleanAreaPoint.Count >= 4");
                    temp_width = map.CleanAreaPoint[map.CleanAreaPoint.Count - 3].X;
                }
                if (r.get_R_X() + r.R_Width >= temp_width)
                {
                    if (map.CleanAreaPoint.Count >= 4)
                    {
                        map.CleanAreaPoint.Add(new Point(r.get_R_X(), r.get_R_Y()));
                    }
                    if (map.CleanAreaPoint.Count <= 4)
                    {
                        ////////////////////////////////////////////////////////////////////
                        r.set_R_X(-r.get_step());
                        /////////////////////////////////////////////////////////////////////
                    }
                    // 如果不是已绕一周
                    // 增加可清理区域坐标
                    //map.Map_AddCleanAreaPoint(new Point(r.get_R_X() - r.R_Width, r.get_R_Y()));
                    // 改变方向为下
                    //MessageBox.Show("r.set_direction(2);");
                    r.set_direction(2);
                    //this.richTextBox1.Text += "\n改变方向:下";
                }
            }
        }
        /// <summary>
        /// 机器人顺时针向下移动
        /// </summary>
        private void down(Map map, Robot r, Panel panel1)
        {
            int temp_Height = panel1.Size.Height;
            if (r.get_R_Y() + r.R_Height < panel1.Size.Height)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_Y(r.get_step());
                if (map.CleanAreaPoint.Count < 3 && r.get_R_Y() + r.R_Height >= temp_Height)
                {
                    map.CleanAreaPoint.Add(new Point(r.get_R_X(), r.get_R_Y()));
                    // debug
                    //this.richTextBox1.Text += "\nPoint3：(" + r.get_R_X()
                    //                          + "," + r.get_R_Y() + ")";
                }
                if (map.CleanAreaPoint.Count >= 4)
                {
                    temp_Height = map.CleanAreaPoint[map.CleanAreaPoint.Count - 4].Y;
                    //temp_Height = temp_Height;
                    //MessageBox.Show(temp_Height.ToString()); 
                }
                if (r.get_R_Y() + r.R_Height >= temp_Height)
                {
                    if (map.CleanAreaPoint.Count >= 4)
                    {
                        map.CleanAreaPoint.Add(new Point(r.get_R_X(), r.get_R_Y()));
                    }
                    r.set_R_Y(-r.get_step());
                    // 改变方向为左
                    //this.richTextBox1.Text += "\n改变方向:左";
                    r.set_direction(3);
                }
            }
        }
        /// <summary>
        /// 机器人顺时针向左移动
        /// </summary>
        private void left(Map map, Robot r, Panel panel1)
        {
            int left = 0;
            if (map.CleanAreaPoint.Count >= 4)
            {
                left = map.CleanAreaPoint[map.CleanAreaPoint.Count - 4].X;
                //MessageBox.Show(left.ToString() + (map.CleanAreaPoint.Count - 2).ToString());
            }
            if (r.get_R_X() > left)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_X(-r.get_step());
                if (r.get_R_X() <= left)
                {
                    if (map.CleanAreaPoint.Count < 4)
                    {
                        map.CleanAreaPoint.Add(new Point(r.get_R_X() + r.R_Width, r.get_R_Y()));
                        // debug
                        //this.richTextBox1.Text += "\nPoint4：(" + r.get_R_X()
                        //                          + "," + r.get_R_Y() + ")";
                    }
                    else
                    {
                        map.CleanAreaPoint.Add(new Point(r.get_R_X() + r.R_Width, r.get_R_Y()));
                    }
                    r.set_R_X(r.get_step());
                    // 改变方向为上
                    r.set_direction(4);
                    //MessageBox.Show("r.set_direction(4);");
                    //this.richTextBox1.Text += "\n改变方向:上";
                    //// 记录下此时的坐标 X, Y
                    //points.Add(new Point(r.get_R_X(), r.get_R_Y()));
                }
            }
        }
        /// <summary>
        /// 机器人顺时针向上移动
        /// </summary>
        private void up(Map map, Robot r, Panel panel1)
        {
            int up = 0;
            if (map.CleanAreaPoint.Count >= 4)
            {
                up = map.CleanAreaPoint[map.CleanAreaPoint.Count - 4].Y;
            }
            if (r.get_R_Y() > up)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_Y(-r.get_step());
                if (r.get_R_Y() <= up)
                {
                    r.set_R_Y(r.get_step());
                    // 改变方向为右
                    if (r.get_R_Y() <= map.CleanAreaPoint[map.CleanAreaPoint.Count - 4].Y)
                    {
                        MessageBox.Show("===========");
                        map.CleanAreaPoint.Add(new Point(r.get_R_X() /*+ r.R_Width*/, r.get_R_Y() + r.R_Height));
                    }
                    if (map.CleanAreaPoint.Count >= 4)
                    {
                        map.CleanAreaPoint.Add(new Point(r.get_R_X() /*+ r.R_Width*/, r.get_R_Y() + r.R_Height /*- r.Ini_R_Y / 3*/ ));
                    }
                    r.set_direction(1);
                    //this.richTextBox1.Text += "\n改变方向:右";
                    //// 记录下此时的坐标 X, Y
                    //points.Add(new Point(r.get_R_X(), r.get_R_Y()));

                }
            }
            //// 判断两个点距离是否小于等于直径
            //if (IsLessDiameter(new Point(r.get_R_X(), r.get_R_Y()), points[0]))
            //{
            //    r.set_direction(1);
            //}
        }
        #endregion
        #region 机器人逆时针方向移动
        /// <summary>
        /// 机器人逆时针向右移动
        /// </summary>
        private void _right(Map map, Robot r, Panel panel1)
        {
            if (r.get_R_X() + r.R_Width < panel1.Size.Width)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_X(r.get_step());
                if (r.get_R_X() + r.R_Width >= panel1.Size.Width)
                {
                    r.set_R_X(-r.get_step());
                    r.set_direction(8);
                    return;
                }
            }
        }
        /// <summary>
        /// 机器人逆时针向下移动
        /// </summary>
        private void _down(Map map, Robot r, Panel panel1)
        {
            if (r.get_R_Y() + r.R_Height < panel1.Size.Height)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_Y(r.get_step());
                if (r.get_R_Y() + r.R_Height >= panel1.Size.Height)
                {
                    r.set_R_Y(-r.get_step());
                    r.set_direction(5);
                    return;
                }
            }
        }
        /// <summary>
        /// 机器人逆时针向左移动
        /// </summary>
        private void _left(Map map, Robot r, Panel panel1)
        {
            if (r.get_R_X() > 0)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_X(-r.get_step());
                if (r.get_R_X() <= 0)
                {
                    r.set_R_X(r.get_step());
                    r.set_direction(6);
                    return;
                }
            }
        }
        /// <summary>
        /// 机器人逆时针向上移动
        /// </summary>
        private void _up(Map map, Robot r, Panel panel1)
        {
            if (r.get_R_Y() > 0)
            {
                r.drawRobot(r, panel1); ;   //画轨迹
                r.set_R_Y(-r.get_step());
                if (r.get_R_Y() <= 0)
                {
                    r.set_R_Y(r.get_step());
                    r.set_direction(7);
                    return;
                }
            }
        }
        #endregion
        #region 辅助类
        /// <summary>
        /// 是否小于等于直径
        /// </summary>
        /// <param name="_p1">点1</param>
        /// <param name="_p2">点2</param>
        /// <returns></returns>
        private bool IsLessDiameter(Robot r, Point _p1, Point _p2)
        {
            int delta_x = _p1.X - _p2.X;
            int delta_y = _p1.Y - _p2.Y;
            if (delta_x * delta_x + delta_y * delta_y <= r.R_Width * r.R_Width)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 比较Robot与DirtyArea中心的距离
        /// </summary>
        /// <param name="d"></param>
        /// <param name="r"></param>
        /// <returns></returns>
        private bool IsBiggerThanDiameter(Robot r, DirtyArea d)
        {
            int delta_x = r.get_Center_X_Y().X - (d.D_X + d.D_Width / 2);
            int delta_y = r.get_Center_X_Y().Y - (d.D_Y + d.D_Height / 2);
            if (delta_x * delta_x + delta_y * delta_y >= d.D_Width * d.D_Width)
            {
                return true;
            }
            return false;
        }
        /// <summary>
        /// 判断数字1是否大于数字2
        /// </summary>
        /// <param name="i">数字1</param>
        /// <param name="j">数字2</param>
        /// <returns></returns>
        private int BiggerThan(float i, float j)
        {
            if (i >= j)
                return 1;
            else
                return -1;
        }
        #endregion
    }
}
